import java.util.Arrays;

/**
 * Description:
 * Date: 2025-10-02
 * Time: 12:16
 */
public class Test {

    public static int max2(int a, int b){
        return a > b? a: b;
    }

    public static int max3(int m, int n,int i){
        int ret = max2(m,n);
        return ret > i? ret: i;
    }

    //使用函数求最大值
    public static void main1(String[] args) {
        System.out.println(max3(31,4,55));
    }

    public static void add(int m, int n){
        System.out.println(m + n);
    }

    public static void add(double a, double b, double c){
        System.out.println(a + b +c);
    }

    //求和的重载
    public static void main2(String[] args) {
        add(10,20);
        add(3.1,4.2,5.3);
    }

    public static int max(int m, int n){
        return Math.max(m,n);
    }

    public static double max(double a, double b, double c){
//        double ret = Math.max(a,b);
        return Math.max(Math.max(a,b),c);

    }


    //求最大值方法的重载
    public static void main3(String[] args) {
        int in = max(3,10);
        double dou = max(1.1,0.89,10.11);
        System.out.println(in);
        System.out.println(dou);
    }

    //数组
    public static void main4(String[] args) {
        //数组：是相同类型元素的一个集合，在内存中是一段连续的空间，空间有编号，从0开始，简称为下标
        //数组的创建语法；数据类型 + 变量名
        int[] array = {1,2,3,4,5,6};//创建数组时同时进行数组的初始化
        //new 是创建一个对象，所以 array array1 是引用变量，俗称引用 储存的是数组的地址
        int[] array1 = new int[]{1,2,3,4,5,6};//与上面的创建数组没有区别

        int[] array2 = new int[10];//没有对数组进行初始化，只确定了数组的长度，此时数组里面元素默认为0
//            array2 = {1，2，3，4，5，6};对数组的初始化只能在定义数组的时候进行
    }

    public static void main5(String[] args) {
        int[] array = {1,2,3,4,5,6};
        for (int i = 0; i < array.length; i++) {//array.lehgth 能获得数组的长度
            System.out.print(array[i] + " ");
        }
        System.out.println();

        //for each 循环
        for (int x:array) {//左边是数组中元素的类型，右边是数组名称
            //将数组中的元素赋予变量x中， 但只能  遍历数组，无法取出下标来
            System.out.print(x + " ");
        }
        System.out.println();

        //通过Arrays调用库方法toString()来输出数组  输出的内容以字符串的形式输出
        System.out.println(Arrays.toString(array));
    }

    public static void main6(String[] args) {
        int[] array1 = new int[3];
        array1[0] = 10;
        array1[1] = 20;
        array1[2] = 30;
        System.out.println(Arrays.toString(array1));
        int[] array2 = new int[]{1,2,3,4,5};
        array2[0] = 100;
        array2[1] = 200;
        System.out.println(Arrays.toString(array2));
        array1 = array2;//这个是将array2的引用给了array1，及array1和array2同时指向array2所指向的数组
        //此时array1操作会改变array2所指向的数组 ==== 而array1之前指向的对象（数组），因为没有引用指向它，会被jvm回收内存
        array1[2] = 300;
        array1[3] = 400;
        array1[4] = 500;
        System.out.println(Arrays.toString(array2));
    }

    public static void main7(String[] args) {
        int[] array = null;//初始化为null，说明array这个引用不指向任何一个对象
        //当一个空引用尝试调用某个对象或变量时，会引发空指针异常 NullPointerException
        //Java中没有空指针的说法，这个异常底层是C++代码研发，空指针只是一种形式
        System.out.println(array.length);
    }

    public static void func(int[] array){
        //array这个形参中放的是array1的引用，也指向array1所指向的数组
        //在array上对数组进行修改相当于在array1上修改
        array[0] = 99;
    }

    public static void main8(String[] args) {
        int[] array1 = {1,2,3,4,5};
        func(array1);
        System.out.println(Arrays.toString(array1));
    }

    public static int[] func1(int[] array){
        //将数组扩大两倍
        int ret[] = new int[array.length];
        for (int i = 0; i < array.length; i++){
            ret[i] = array[i] * 2;
        }

        return ret;
    }

    public static void main9(String[] args) {
        int[] array1 = {1,2,3,4};
        int tmp[] = func1(array1);//额外创建一个数组容纳原数组对其元素的修改
        System.out.println(Arrays.toString(array1));
        System.out.println(Arrays.toString(tmp));
    }

    public static int[] func2(int [] array){
        for (int i = 0; i < array.length; i++) {
            array[i] = array[i] * 2;
        }
        return array;
    }
    public static void main10(String[] args) {
        int[] array1 = {1,2,3,4};
        func2(array1);//对数组本身进行扩大两倍的修改
        System.out.println(Arrays.toString(array1));
    }

    public static void func3(int[] array){
        //此时形参array指向了另一个引用，不再指向array1的引用，array对数组值的修改不影响array1数组中的值的修改
        //一个引用不能同时指向2个对象
        array = new int[]{5,6,7,8};
        //方法结束之后，array所指向的引用也会被jvm回收
    }

    public static void main11(String[] args) {
        int[] array1 = {1,2,3,4};
        func3(array1);
        System.out.println(Arrays.toString(array1));
    }

    public static void binarySearch(int array[], int key){
        int n = array.length;
        int left = 0;
        int right = n - 1;
        while (left <= right){
            int mid = (left + right) / 2;
            if(array[mid] > key){
                right = mid - 1;
            }else if (array[mid] < key){
                left = mid + 1 ;
            }else {
                System.out.println("找到了，下标为：" + mid);
                return;
            }
        }
        System.out.println("没有找到目标值");

    }

    //二分查找 (必须在有序的数组中进行查找，即从小到大排序)
    public static void main12(String[] args) {
        int[] array = {1,11,81,4,13};
        System.out.println("排序前的数组：" + Arrays.toString(array));
        Arrays.sort(array);
        System.out.println("排序后的数组：" + Arrays.toString(array));

        //java中有现成的binary search（二分查找方法）
        //int ret = Arrays.binarySearch(array,12);//会返回对应值的下标，没有则会返回一个负数

        //这个是说明二分查找的范围实在【1，3）下标之间寻找。java中的范围一般都是左闭右开的
        System.out.println(Arrays.binarySearch(array,1,3,11));
        //System.out.println(ret);
        //binarySearch(array,81);
    }
    
    public static void bubbleSort(int[] array){
        int n = array.length;
        boolean fal = true;
        for (int i = 0; i < n - 1; i++) {
            for (int j = 0; j < n - 1 - i; j++) {
                if(array[j] > array[j + 1]){
                    fal = false;
                    int tmp = array[j];
                    array[j] = array[j + 1];
                    array[j + 1] = tmp;
                }
            }{
            if(fal = true){
                break;
            }
        }
        }
    }

    //冒泡排序
    public static void main13(String[] args) {
        int[] array = {1,11,81,4,13};
        System.out.println("排序前的数组：" + Arrays.toString(array));
        bubbleSort(array);
        System.out.println("排序后的数组：" + Arrays.toString(array));
    }

    //拷贝数组
    public static void main14(String[] args) {
        int[] array = {1,11,81,4,13};
//        int[] tmp = Arrays.copyOf(array,array.length);
//        int[] tmp1 = Arrays.copyOf(array,array.length * 2);//扩容
//        int[] tmp = Arrays.copyOfRange(array,1,3);//拷贝array数组下标【1，3）范围的数据
        int[] tmp = new int[array.length];
        System.arraycopy(array,0,tmp,0,array.length);
        System.out.println(Arrays.toString(tmp));
    }

    public static void main(String[] args) {
        //数组中数据是否相同
        int[] array1 = {1,11,81,4,13};
        int[] array2 = {1,11,81,4,13};
//        System.out.println(array1 == array2);
        boolean fal = Arrays.equals(array2,array1);//一个一个对比
        System.out.println(fal);

        int[] ret = new int[10];
        Arrays.fill(ret,1,5,3);
        System.out.println(Arrays.toString(ret));
    }


}
